home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / go / prog / sg2ps.sh < prev    next >
Encoding:
Linux/UNIX/POSIX Shell Script  |  1993-06-20  |  36.4 KB  |  1,241 lines
  1. #! /bin/sh
  2. # This is a shell archive, meaning:
  3. # 1. Remove everything above the #! /bin/sh line.
  4. # 2. Save the resulting text in a file.
  5. # 3. Execute the file with /bin/sh (not csh) to create:
  6. #    COPYING
  7. #    README
  8. #    go.ps
  9. #    makefile
  10. #    partie.l
  11. #    partie.y
  12. # This archive created: Sat Mar 21 11:42:18 1992
  13. export PATH; PATH=/bin:/usr/bin:$PATH
  14. if test -f 'COPYING'
  15. then
  16.     echo shar: "will not over-write existing file 'COPYING'"
  17. else
  18. cat << \SHAR_EOF > 'COPYING'
  19.  
  20.             GNU GENERAL PUBLIC LICENSE
  21.              Version 1, February 1989
  22.  
  23.  Copyright (C) 1989 Free Software Foundation, Inc.
  24.                     675 Mass Ave, Cambridge, MA 02139, USA
  25.  Everyone is permitted to copy and distribute verbatim copies
  26.  of this license document, but changing it is not allowed.
  27.  
  28.                 Preamble
  29.  
  30.   The license agreements of most software companies try to keep users
  31. at the mercy of those companies.  By contrast, our General Public
  32. License is intended to guarantee your freedom to share and change free
  33. software--to make sure the software is free for all its users.  The
  34. General Public License applies to the Free Software Foundation's
  35. software and to any other program whose authors commit to using it.
  36. You can use it for your programs, too.
  37.  
  38.   When we speak of free software, we are referring to freedom, not
  39. price.  Specifically, the General Public License is designed to make
  40. sure that you have the freedom to give away or sell copies of free
  41. software, that you receive source code or can get it if you want it,
  42. that you can change the software or use pieces of it in new free
  43. programs; and that you know you can do these things.
  44.  
  45.   To protect your rights, we need to make restrictions that forbid
  46. anyone to deny you these rights or to ask you to surrender the rights.
  47. These restrictions translate to certain responsibilities for you if you
  48. distribute copies of the software, or if you modify it.
  49.  
  50.   For example, if you distribute copies of a such a program, whether
  51. gratis or for a fee, you must give the recipients all the rights that
  52. you have.  You must make sure that they, too, receive or can get the
  53. source code.  And you must tell them their rights.
  54.  
  55.   We protect your rights with two steps: (1) copyright the software, and
  56. (2) offer you this license which gives you legal permission to copy,
  57. distribute and/or modify the software.
  58.  
  59.   Also, for each author's protection and ours, we want to make certain
  60. that everyone understands that there is no warranty for this free
  61. software.  If the software is modified by someone else and passed on, we
  62. want its recipients to know that what they have is not the original, so
  63. that any problems introduced by others will not reflect on the original
  64. authors' reputations.
  65.  
  66.   The precise terms and conditions for copying, distribution and
  67. modification follow.
  68.  
  69.             GNU GENERAL PUBLIC LICENSE
  70.    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  71.  
  72.   0. This License Agreement applies to any program or other work which
  73. contains a notice placed by the copyright holder saying it may be
  74. distributed under the terms of this General Public License.  The
  75. "Program", below, refers to any such program or work, and a "work based
  76. on the Program" means either the Program or any work containing the
  77. Program or a portion of it, either verbatim or with modifications.  Each
  78. licensee is addressed as "you".
  79.  
  80.   1. You may copy and distribute verbatim copies of the Program's source
  81. code as you receive it, in any medium, provided that you conspicuously and
  82. appropriately publish on each copy an appropriate copyright notice and
  83. disclaimer of warranty; keep intact all the notices that refer to this
  84. General Public License and to the absence of any warranty; and give any
  85. other recipients of the Program a copy of this General Public License
  86. along with the Program.  You may charge a fee for the physical act of
  87. transferring a copy.
  88.  
  89.   2. You may modify your copy or copies of the Program or any portion of
  90. it, and copy and distribute such modifications under the terms of Paragraph
  91. 1 above, provided that you also do the following:
  92.  
  93.     a) cause the modified files to carry prominent notices stating that
  94.     you changed the files and the date of any change; and
  95.  
  96.     b) cause the whole of any work that you distribute or publish, that
  97.     in whole or in part contains the Program or any part thereof, either
  98.     with or without modifications, to be licensed at no charge to all
  99.     third parties under the terms of this General Public License (except
  100.     that you may choose to grant warranty protection to some or all
  101.     third parties, at your option).
  102.  
  103.     c) If the modified program normally reads commands interactively when
  104.     run, you must cause it, when started running for such interactive use
  105.     in the simplest and most usual way, to print or display an
  106.     announcement including an appropriate copyright notice and a notice
  107.     that there is no warranty (or else, saying that you provide a
  108.     warranty) and that users may redistribute the program under these
  109.     conditions, and telling the user how to view a copy of this General
  110.     Public License.
  111.  
  112.     d) You may charge a fee for the physical act of transferring a
  113.     copy, and you may at your option offer warranty protection in
  114.     exchange for a fee.
  115.  
  116. Mere aggregation of another independent work with the Program (or its
  117. derivative) on a volume of a storage or distribution medium does not bring
  118. the other work under the scope of these terms.
  119.  
  120.   3. You may copy and distribute the Program (or a portion or derivative of
  121. it, under Paragraph 2) in object code or executable form under the terms of
  122. Paragraphs 1 and 2 above provided that you also do one of the following:
  123.  
  124.     a) accompany it with the complete corresponding machine-readable
  125.     source code, which must be distributed under the terms of
  126.     Paragraphs 1 and 2 above; or,
  127.  
  128.     b) accompany it with a written offer, valid for at least three
  129.     years, to give any third party free (except for a nominal charge
  130.     for the cost of distribution) a complete machine-readable copy of the
  131.     corresponding source code, to be distributed under the terms of
  132.     Paragraphs 1 and 2 above; or,
  133.  
  134.     c) accompany it with the information you received as to where the
  135.     corresponding source code may be obtained.  (This alternative is
  136.     allowed only for noncommercial distribution and only if you
  137.     received the program in object code or executable form alone.)
  138.  
  139. Source code for a work means the preferred form of the work for making
  140. modifications to it.  For an executable file, complete source code means
  141. all the source code for all modules it contains; but, as a special
  142. exception, it need not include source code for modules which are standard
  143. libraries that accompany the operating system on which the executable
  144. file runs, or for standard header files or definitions files that
  145. accompany that operating system.
  146.  
  147.   4. You may not copy, modify, sublicense, distribute or transfer the
  148. Program except as expressly provided under this General Public License.
  149. Any attempt otherwise to copy, modify, sublicense, distribute or transfer
  150. the Program is void, and will automatically terminate your rights to use
  151. the Program under this License.  However, parties who have received
  152. copies, or rights to use copies, from you under this General Public
  153. License will not have their licenses terminated so long as such parties
  154. remain in full compliance.
  155.  
  156.   5. By copying, distributing or modifying the Program (or any work based
  157. on the Program) you indicate your acceptance of this license to do so,
  158. and all its terms and conditions.
  159.  
  160.   6. Each time you redistribute the Program (or any work based on the
  161. Program), the recipient automatically receives a license from the original
  162. licensor to copy, distribute or modify the Program subject to these
  163. terms and conditions.  You may not impose any further restrictions on the
  164. recipients' exercise of the rights granted herein.
  165.  
  166.   7. The Free Software Foundation may publish revised and/or new versions
  167. of the General Public License from time to time.  Such new versions will
  168. be similar in spirit to the present version, but may differ in detail to
  169. address new problems or concerns.
  170.  
  171. Each version is given a distinguishing version number.  If the Program
  172. specifies a version number of the license which applies to it and "any
  173. later version", you have the option of following the terms and conditions
  174. either of that version or of any later version published by the Free
  175. Software Foundation.  If the Program does not specify a version number of
  176. the license, you may choose any version ever published by the Free Software
  177. Foundation.
  178.  
  179.   8. If you wish to incorporate parts of the Program into other free
  180. programs whose distribution conditions are different, write to the author
  181. to ask for permission.  For software which is copyrighted by the Free
  182. Software Foundation, write to the Free Software Foundation; we sometimes
  183. make exceptions for this.  Our decision will be guided by the two goals
  184. of preserving the free status of all derivatives of our free software and
  185. of promoting the sharing and reuse of software generally.
  186.  
  187.                 NO WARRANTY
  188.  
  189.   9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  190. FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
  191. OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  192. PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  193. OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  194. MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
  195. TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
  196. PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  197. REPAIR OR CORRECTION.
  198.  
  199.   10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  200. WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  201. REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  202. INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  203. OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  204. TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  205. YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  206. PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  207. POSSIBILITY OF SUCH DAMAGES.
  208.  
  209.              END OF TERMS AND CONDITIONS
  210. SHAR_EOF
  211. fi
  212. if test -f 'README'
  213. then
  214.     echo shar: "will not over-write existing file 'README'"
  215. else
  216. cat << \SHAR_EOF > 'README'
  217.  
  218. Here comes the program to convert go games in the mgt format to
  219. a postscript program. I looked in the archive in september 1990
  220. and found nothing to do the same job.
  221.  
  222. I used this program to convert the games of Shusaku and Go Seigen
  223. stored in the archive. All went well, except for a few files which
  224. contained what i supposed being typing errors not recognized by
  225. mgt.
  226.  
  227. The postcript programming style is definitely poor, when seeing
  228. what is recommended by the green book.
  229.  
  230. If you want to make modifications to the program, it would be nice
  231. to send them to me. It is heavily commented ; that will be useful
  232. for those who speak french.
  233.  
  234. Jean Mehat.
  235.  
  236.  
  237.  
  238. ------------
  239.  
  240. To use this program on a unix system, type
  241.    make
  242. to compile the program.
  243.  
  244. Then run with
  245.    mgt2ps < inputfile > outputfile.ps
  246.  
  247. SHAR_EOF
  248. fi
  249. if test -f 'go.ps'
  250. then
  251.     echo shar: "will not over-write existing file 'go.ps'"
  252. else
  253. cat << \SHAR_EOF > 'go.ps'
  254. %!PS-Adobe-1.0
  255. %%Creator: mgt2ps
  256. %%Title: une partie de go
  257. %%Pages: (atend)
  258. %%DomumentFonts: Times-Roman
  259. %%EndComments
  260.  
  261. % Afficher un goban, avec son titre, ses recouvrements, ses kos,
  262. % ses commentaires, comme produit par mgt2ps
  263. %                    jm, octobre 1990
  264. % (c) Jean Mehat, Octobre 1990
  265. % De'partement d'informatique, universite de Paris 8, 2 rue de la liberte,
  266. %    St Denis, 93526 cedex 02, France
  267. % jm@aristote.univ-paris8.fr ou
  268. % jm@geocub.greco-prog.fr
  269. %
  270. %    This program is free software; you can redistribute it and/or modify
  271. %    it under the terms of the GNU General Public License as published by
  272. %    the Free Software Foundation; either version 1, or (at your option)
  273. %    any later version.
  274. %
  275. %    This program is distributed in the hope that it will be useful,
  276. %    but WITHOUT ANY WARRANTY; without even the implied warranty of
  277. %    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  278. %    GNU General Public License for more details.
  279. %
  280. %    You should have received a copy of the GNU General Public License
  281. %    along with this program; if not, write to the Free Software
  282. %    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  283.  
  284. % decembre 1990 : re-ecrit centrer pour qu'il mesure vraiment les caracteres
  285. % qu'il centre
  286.  
  287.     % la taille du goban
  288. /gobantaille 19 def        % taille du goban
  289. /h1 4 def            % h1, h2, h3 : les hoshis
  290. /h2 gobantaille 1 add h1 sub def
  291. /h3 gobantaille 1 add 2 div def
  292.  
  293.     % le dessin du goban
  294. /epaisseur 1 def        % epaisseur du trait du goban
  295. /vespace 22 def            % ecart entre les traits vertical et horizontal
  296. /hespace 20 def
  297.  
  298.     % le dessin des pierres
  299. /prayon hespace 1 sub 2 div def    % rayon d'une pierre : (hespace-1)/2
  300.                 % fonte pour etiqueter les pierres
  301. /eticar /Times-Roman findfont prayon scalefont def
  302.  
  303.     % l'e'criture des notes et commentaires
  304. /noteEchelle 12 def        % echelle de la fonte
  305.                 % fonte pour commenter les coups
  306. /notecar /Times-Roman findfont noteEchelle scalefont def
  307. /notespace prayon dup 2 add add def
  308. /pierrechelle             % echelle pour avoir une pierre de meme taille
  309.                 %   que du texte
  310.    noteEchelle prayon dup add div
  311.  def
  312.  
  313.     % dessiner des pierres (en 0 0) : noire00, blanche00
  314. /noire00
  315.   { 0 setgray newpath 0 0 prayon 0 360 arc fill
  316.   } def
  317. /blanche00
  318.   { newpath 0 0 prayon 0 360 arc
  319.      gsave 1 setgray fill grestore 0 setgray stroke
  320.   } def
  321.  
  322.     % dessiner un goban
  323. /goban00 {
  324.   epaisseur setlinewidth
  325.   newpath
  326.     1 1 gobantaille {
  327.       dup dup dup            % i i i i
  328.       1 goban2coord moveto        % i i i
  329.       gobantaille goban2coord lineto    % i i
  330.       1 exch goban2coord moveto        % i
  331.       gobantaille exch goban2coord lineto
  332.     } for
  333.   stroke
  334.  
  335.   newpath
  336.    [ h1 h2 h3 ]
  337.    {                 % n
  338.      dup dup            % n n n
  339.      [ h1 h2 h3 ] {        % --- n m
  340.     goban2coord        % --- x y
  341.     2 copy moveto
  342.     3 0 360 arc   
  343.       } forall
  344.     } forall
  345.   fill
  346. } def
  347.  
  348.  
  349. /centrer    % (nom) -> (nom) mais il a fait un moveto, (nom) sera centre
  350. {
  351.   gsave
  352.     newpath 0 0 moveto dup true charpath flattenpath pathbbox
  353.                 % (nom) xmin ymin xmax ymax
  354.     2 index sub            % (nom) xmin ymin xmax haut
  355.     exch 3 index sub        % (nom) xmin ymin haut large
  356.                 % (nom) xmin ymin -large/2 -haut/2
  357.     2 div neg exch 2 div neg
  358.   grestore
  359.   moveto            % (nom) xmin ymin
  360.   pop pop            % (nom)
  361. } def
  362.  
  363. /tpierre {    % (nom) couleur -> - ; affiche une pierre a la show
  364.   gsave
  365.     currentpoint translate
  366.     1 prayon add noteEchelle 2 div translate
  367.     2 eq { noire00 1 } { blanche00 0 } ifelse
  368.     setgray eticar setfont centrer show
  369.   grestore
  370.   prayon dup add 2 add 0 rmoveto    % deplace le point courant a la show
  371. } def
  372.  
  373.     % parametrer l'organisation de la page
  374. /Mg 50 def            % marges gauche et droite
  375. /Md 8.5 72 mul Mg Mg add sub def
  376. /Mb 1 72 mul def        % marges basses et hautes
  377. /Mh 11 72 mul Mb sub def
  378.  
  379. /initHaut {
  380.   /hautx Mg def            % le plus haut point courant a utiliser
  381.   /hauty Mh def            %   (modifie par titre et utilise par goban)
  382. } def
  383.  
  384. /goban {
  385.   /gobanx hautx def            % coordonne'es du goban
  386.   /gobany hauty vespace gobantaille mul sub def
  387.   goban00
  388.                     % coord. des reprises : "12 en 5"
  389.   /couvrex gobanx hespace gobantaille 1 add mul add def
  390.   /couvrey gobany vespace gobantaille 2 sub mul add def
  391.                     % coordonne'es des commentaires et, si
  392.   /comx gobanx def            % il faut, des kos : "12, 15, 17 en 5"
  393.   /comy gobany notespace 2 mul sub def
  394. } def
  395.  
  396. /goban2coord    % n m -> x y
  397.  {
  398.     exch
  399.     1 sub exch gobantaille exch    sub    % x-1 gobantaille-y
  400.     vespace mul exch hespace mul exch    % (x-1)hespace (gbt-y)vespace
  401.     gobany add exch gobanx add exch    % (x-1)hespace+gobanx (gbt-y)vespace+gobany
  402.  } def
  403.  
  404.     % justification a la hache : on pose les mots, si on a depasse la
  405.     % marge droite, on va a la ligne, si on a depasse la marge basse
  406.     % on passe a la ligne suivante
  407. /lignespace notespace def    % espace entre deux lignes
  408.  
  409. /addpierre {        % (nom) couleur ->
  410.   tpierre
  411.   currentpoint pop        % (n) c x
  412.   Md gt { comalaligne } if
  413. } def
  414.  
  415. /addchaine {        % string ->
  416.   ( ) search            % post match pre true OU string false
  417.   { addmot show addchaine } { addmot } ifelse
  418. } def
  419.  
  420. /addmot {        % mot ->
  421.   show                % mot
  422.   currentpoint pop        % mot w+y
  423.   Md gt { comalaligne } if
  424. } def
  425.  
  426. /comalaligne {
  427.   /comy comy lignespace sub def
  428.   comy Mb le { showpage /comy Mh def } if
  429.   comx comy moveto
  430. } def
  431.   
  432. %
  433. % titres    traite un tableau de chaines qui servent de titre
  434. % coups        traite un tableau de coups ( = [nom) couleur ligne col ])
  435. % couvres      ... un tableau de pierres qui en recouvrent d'autres :
  436. %                ( = [(sous) couleur [ (sur) couleur ]])
  437. % kos          ... un tableau de liste de pierres qui en recouvrent d'autres
  438. %                ( = [(sous) c [ (sur1) c1 (sur2) c2 ... ]])
  439. % commentaires       ... un tableau de commentaires ( = [ (nom) couleur (comm) ] )
  440. %
  441.  
  442. /titres        % [ (chaine) (chaine) ... ]
  443. { initHaut
  444.   {
  445.     hautx hauty moveto notecar setfont show
  446.     /hauty hauty noteEchelle sub def
  447.   } forall
  448. } def
  449.  
  450. /coups        % [ [ (nom) coul n m ] [ (nom) coul n m ] ... ]
  451. { {                % --- [ (nom) coul n m ]
  452.     aload pop            % --- (nom) coul n m
  453.     gsave
  454.       goban2coord translate
  455.       2 eq { noire00 1 } { blanche00 0 } ifelse
  456.       setgray eticar setfont centrer show
  457.     grestore
  458.   } forall
  459. } def
  460.  
  461. /couvres            % [ [ (sous) couleur [ (sur) couleur ] ] --- ]
  462. {
  463.   gsave
  464.     couvrex couvrey moveto
  465.     {                % --- [ (sous) c [ (sur) c ]]
  466.       aload pop            % --- (sous) c [ (sur) c ]
  467.       aload pop            % --- (sous) c (sur) c
  468.       tpierre ( en ) show tpierre
  469.       couvrex couvrey notespace sub dup /couvrey exch def
  470.       moveto
  471.     } forall
  472.     /couvrey couvrey notespace sub def
  473.   grestore
  474. } def
  475.  
  476. /kos {            % [[ko] [ko] ...]
  477.   comx comy moveto
  478.   lignespace notespace def
  479.   {                % ... ko=[(nom) couleur [(nom) couleur ... ]]
  480.     aload pop            % (sous) c [coups]
  481.     true exch            % (sous) c flag [coups]
  482.     {
  483.       exch            % (sous) c (nom) true
  484.                 %  ou bien (nom) c false
  485.       { false } { addpierre true } ifelse
  486.     } forall
  487.     pop                % (sous) c
  488.     ( en ) addchaine
  489.     addpierre
  490.     comalaligne
  491.   } forall
  492.   comalaligne
  493. } def
  494.  
  495. /commentaires        % [ [ (nom) couleur (commentaire) ] --- ]
  496. {
  497.   comx comy moveto
  498.   lignespace noteEchelle def
  499.   { aload pop                % -> (n) couleur (com)
  500.     3 1 roll            % -> (com) (n) couleur
  501.     dup dup            % -> (com) (n) couleur couleur couleur
  502.     1 eq            % -> (com) (n) couleur couleur bool
  503.     exch            % -> (com) (n) couleur bool couleur
  504.     2 eq            % -> (com) (n) couleur bool bool
  505.     or {  pierrechelle dup scale
  506.       addpierre
  507.       1 pierrechelle div dup scale
  508.       ( ) show
  509.        } { pop pop } ifelse    % com
  510. %    or { addpierre ( ) show } { pop pop } ifelse
  511.     addchaine            % ->
  512.     comalaligne
  513.   } forall
  514. } def
  515.  
  516. %%EndProlog
  517. SHAR_EOF
  518. fi
  519. if test -f 'makefile'
  520. then
  521.     echo shar: "will not over-write existing file 'makefile'"
  522. else
  523. cat << \SHAR_EOF > 'makefile'
  524. #
  525. # mgt2ps : traduit une partie note'e dans le format mgt en programme postscript
  526. # 
  527. # (c) Jean Mehat, Octobre 1990
  528. # De'partement d'informatique, universite de Paris 8, 2 rue de la liberte,
  529. #    St Denis, 93526 cedex 02, France
  530. # jm@aristote.univ-paris8.fr ou
  531. # jm@geocub.greco-prog.fr
  532. #
  533. #    This program is free software; you can redistribute it and/or modify
  534. #    it under the terms of the GNU General Public License as published by
  535. #    the Free Software Foundation; either version 1, or (at your option)
  536. #    any later version.
  537. #
  538. #    This program is distributed in the hope that it will be useful,
  539. #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  540. #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  541. #    GNU General Public License for more details.
  542. #
  543. #    You should have received a copy of the GNU General Public License
  544. #    along with this program; if not, write to the Free Software
  545. #    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  546. #
  547. CC = gcc
  548. CFLAGS = -g -O -o mgt2ps
  549. BINDIR = /usr/local/bin
  550. PSLIBDIR = `pwd`
  551.  
  552. mgt2ps : partie.tab.c lex.yy.c
  553.     $(CC) $(CFLAGS) -DYYDEBUG -DPSFILE=\"$(PSLIBDIR)/go.ps\" partie.tab.c
  554.  
  555. clean :
  556.     rm -f partie.tab.c lex.yy.c *.o a.out core *~
  557.  
  558.  
  559. lex.yy.c : partie.l
  560.     flex partie.l
  561.  
  562. partie.tab.c : partie.y
  563.     bison partie.y
  564.  
  565. install: mgt2ps
  566.     mv mgt2ps $(BINDIR)/mgt2ps
  567. SHAR_EOF
  568. fi
  569. if test -f 'partie.l'
  570. then
  571.     echo shar: "will not over-write existing file 'partie.l'"
  572. else
  573. cat << \SHAR_EOF > 'partie.l'
  574.   /* partie.l
  575.    decouper un fichier mgt en lexemes
  576.  
  577.  (c) Jean Mehat, Octobre 1990
  578.  De'partement d'Informatique, Universite de Paris 8, 2 rue de la liberte,
  579.     St Denis, 93526, Cedex 02, France
  580.  jm@geocub.greco-prog.fr
  581.  
  582.     This program is free software; you can redistribute it and/or modify
  583.     it under the terms of the GNU General Public License as published by
  584.     the Free Software Foundation; either version 1, or (at your option)
  585.     any later version.
  586.  
  587.     This program is distributed in the hope that it will be useful,
  588.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  589.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  590.     GNU General Public License for more details.
  591.  
  592.     You should have received a copy of the GNU General Public License
  593.     along with this program; if not, write to the Free Software
  594.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  595.    */
  596.   int lino = 1;
  597. PASDECROCHETFERMANT        ([^\][])
  598. %%
  599. Name                { return NAME; }
  600. PLayer                { return PLAYER; }
  601. GaMe                { return GAME; }
  602. Si[zZ]e                { return SIZE; }
  603. VieW                { return VIEW; }
  604. WhiteSpec            { return WHITESPEC; }
  605. BlackSpec            { return BLACKSPEC; }
  606. PlaCe                { return PLACE; }
  607. DaTe                { return DATE; }
  608. FileFormat            { return FILEFORMAT; }
  609. GameName            { return GAMENAME; }
  610. K[oO]                { return KO; }
  611. AddBlack            { return ADDBLACK; }
  612. AddWhite            { return ADDWHITE; }
  613. AddEmpty            { return ADDEMPTY; }
  614. Letter                { return LETTER; }
  615. Mark                { return MARK; }
  616. Comment                { return COMMENT; }
  617. Black                { return BLACK; }
  618. White                { return WHITE; }
  619. "["    { /* Pour les args, c'est la merde parce qu'on a parfois des \[ et \]
  620.          et parfois des [] imbrique's ; il faut escaper ( et ) */
  621.       static char * monarg = 0;
  622.       static int place = 0;
  623.       int nivo, prev, c;
  624.       int i;
  625.       static int input();        /* pour eviter un warning de gcc */
  626.  
  627.       if (monarg == 0 && (monarg = (char *)calloc(place = 1024, 1)) == 0)
  628.         merror();
  629.  
  630.       for(nivo = i = 0;;){
  631.         c = input();
  632.                 /* on s'arrete ? */
  633.         if (c == ']' && (i == 0 || monarg[i - 1] != '\\') && nivo == 0)
  634.           break;
  635.                 /* allouew ou realloue si necessaire */
  636.         if (i >= place - 1
  637.         && (monarg = (char *)realloc(monarg, place += 1024)) == 0)
  638.           merror();
  639.                 /* compte les returns */
  640.         if (c == '\n')
  641.           lino += 1;
  642.                 /* transforme les () en \(\)*/
  643.         if ((c == '(' || c == ')') && (i == 0 || monarg[i - 1] != '\\'))
  644.           monarg[i++] = '\\';
  645.                 /* compte les [] sans \,
  646.                    transforme les en \[\]*/
  647.         if ((c == '[' || c == ']') && (i == 0 || monarg[i - 1] != '\\')){
  648.           if (c == '[')
  649.         nivo += 1;
  650.           else if (c == ']')
  651.         nivo -= 1;
  652.           monarg[i++] = '\\';
  653.         }
  654.                 /* maintenant, ajoute le caractere */
  655.         monarg[i++] = c;
  656.       }
  657.       monarg[i] = 0;
  658.       yylval.pcar = monarg;
  659.       return ARG;
  660.     }
  661. [;()]                { return yytext[0]; }
  662. [ \t]                ;
  663. \n                { lino += 1; }
  664. .                { extern char * file; printf("%s:%d: %c\n",
  665.                      file, lino, yytext[0]); }
  666. %%
  667. SHAR_EOF
  668. fi
  669. if test -f 'partie.y'
  670. then
  671.     echo shar: "will not over-write existing file 'partie.y'"
  672. else
  673. cat << \SHAR_EOF > 'partie.y'
  674. /* partie.y  --  comvertit du format mgt (Smart Go ?) en postscript
  675.  
  676.  (c) Jean Mehat, Octobre 1990
  677.  De'partement d'informatique, universite de Paris 8, 2 rue de la liberte,
  678.     St Denis, 93526 cedex 02, France
  679.  jm@aristote.univ-paris8.fr ou
  680.  jm@geocub.greco-prog.fr
  681.  
  682.     This program is free software; you can redistribute it and/or modify
  683.     it under the terms of the GNU General Public License as published by
  684.     the Free Software Foundation; either version 1, or (at your option)
  685.     any later version.
  686.  
  687.     This program is distributed in the hope that it will be useful,
  688.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  689.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  690.     GNU General Public License for more details.
  691.  
  692.     You should have received a copy of the GNU General Public License
  693.     along with this program; if not, write to the Free Software
  694.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  695.  */
  696.  
  697. /*
  698.  En general, convertit le format mgt (Smart Go ?) en suite de commandes
  699.  postscript. Quoiqu'en dise main, ca ne marche qu'avec 0 ou 1 partie (le
  700.  probleme est peut etre dans l'input() de flex ?
  701.                 jm, octobre&novembre 1990
  702. 7 novembre 90 : affiche aussi les pierres de handicap
  703. 12 novembre 90 : affiche le goban et les pierres sur la meme page,
  704.     meme s'il y a beaucoup de kos. Libere la memoire des kos.
  705.  */
  706. %token GAME SIZE VIEW BLACKSPEC WHITESPEC FILEFORMAT GAMENAME KO PLACE
  707. %token DATE LETTER NAME PLAYER
  708. %token ADDEMPTY MARK ADDBLACK ADDWHITE
  709. %token COMMENT WHITE BLACK
  710.  
  711. %token <pcar> ARG
  712.  
  713. %union {
  714.   char *    pcar;    
  715.   struct noeud *n;
  716. }
  717.  
  718. %type <n> coup liste variante
  719.  
  720. %{
  721. # include <assert.h>
  722.  
  723. # define BLANC 1
  724. # define NOIR 2
  725.  
  726. # define VARIANTE 1
  727. # define COUP    2
  728. # define HANDICAP 3
  729.  
  730. # define GOBAN 19
  731.  
  732. typedef struct point { int x, y; } Point;
  733.  
  734. typedef struct noeud {
  735.   int flag;
  736.   struct noeud * next;
  737.   struct noeud * fils;
  738.   char * commentaire;
  739.   int couleur;
  740.   Point position;
  741.   int numcoup;
  742.   int ndessus;
  743.   struct noeud * dessous;
  744. } Noeud;
  745.                 /* gcc les fera inline */
  746. static Point Pt(a, b){ Point p; p.x = a; p.y = b; return p; }
  747. static Noeud * courant;
  748. static Noeud * nouvo(){ Noeud * n;
  749.   if ((n = (Noeud *)calloc(1, sizeof n[0])) == 0)
  750.     merror();
  751.   return courant = n;
  752. }
  753. static void ancien(n) Noeud *n; {
  754.   if (n->commentaire != 0)
  755.     free(n->commentaire);
  756.   if (n->fils != 0)
  757.     ancien(n->fils);
  758.   if (n->next != 0)
  759.     ancien(n->next);
  760.   free(n);
  761. }
  762. static char * interne(s) char * s; { char * d;
  763.   if ((d = (char *)malloc(strlen(s) + 1)) == 0)
  764.     merror();
  765.   else
  766.     strcpy(d, s);
  767.   return d;
  768. }
  769.  
  770.  
  771. Noeud * racine;            /* On trouve la partie parse'e ici */
  772. %}
  773.  
  774. %%
  775. racine    : '(' ';' 
  776.         { $<n>$ = nouvo(); }
  777.       props1 liste ')'
  778.         { racine = $<n>3;
  779.           racine->next = $5;
  780.         }
  781.     ;
  782.  
  783. variante
  784.     : '(' liste ')'
  785.         { $$ = nouvo();
  786.           $$->flag = VARIANTE;
  787.           $$->fils = $2;
  788.         }
  789.     ;
  790.  
  791. liste    : coup liste
  792.         { goto chainer; }
  793.     | coup
  794.       | variante liste
  795.         { chainer:
  796.             $1->next = $2;
  797.             $$ = $1;
  798.         }
  799.     | variante
  800.     ;
  801.  
  802. coup    : ';'
  803.         { $<n>$ = nouvo(); }
  804.       props
  805.         { $$ = $<n>2;
  806.           $$->flag = COUP;
  807.         }
  808.     ;
  809.  
  810. props    : prop props
  811.     | /* rien */
  812.     ;
  813.  
  814. prop    : GAME ARG
  815.     | PLAYER ARG
  816.     | KO ARG
  817.     | MARK liste_arg
  818.     | ADDBLACK liste_arg
  819.         { noparse(); }
  820.     | ADDWHITE liste_arg
  821.         { noparse(); }
  822.     | ADDEMPTY liste_arg
  823.         { noparse(); }
  824.     | LETTER liste_arg
  825.     | COMMENT ARG
  826.         { courant->commentaire = interne($2); }
  827.     | WHITE ARG
  828.         { courant->couleur = BLANC;
  829.         addcourant:
  830.           assert($2[0] >= 'a' && $2[0] <= 's'
  831.              && $2[1] >= 'a' && $2[1] <= 's'
  832.              && $2[2] == 0);
  833.           courant->position = Pt($2[0] - 'a' + 1, $2[1] - 'a' + 1);
  834.         }
  835.     | BLACK ARG
  836.           { courant->couleur = NOIR;
  837.           goto addcourant;
  838.         }
  839.     | NAME ARG
  840.     ;
  841.  
  842. /* Les proprietes qu'on ne trouve que sur le premier noeud */
  843. props1    : prop1 props1
  844.     | prop props1
  845.     | /* rien */
  846.     ;
  847. prop1    : SIZE ARG
  848.     | PLACE ARG
  849.     | DATE ARG
  850.     | FILEFORMAT ARG
  851.     | GAMENAME ARG
  852.     | VIEW ARG
  853.     | BLACKSPEC ARG
  854.     | WHITESPEC ARG
  855.     ;
  856.  
  857. liste_arg
  858.     : ARG liste_arg
  859.         { ; }
  860.     | ARG
  861.         { ; }
  862.     ;
  863. %%
  864. tfaire(courant, s) Noeud * courant; char * s; {
  865.   courant->position = Pt(s[0] - 'a' + 1, s[1] - 'a' + 1);
  866. }
  867.  
  868. # include "lex.yy.c"
  869. # include <ctype.h>
  870.  
  871. # ifndef PSFILE
  872. #    define PSFILE    "go.ps"
  873. # endif
  874.  
  875. char * file = "stdin";
  876.  
  877. main(ac, av)
  878.      char * av[];
  879. {
  880.   int compte = 1;
  881.   void arbre2ps();
  882.  
  883.  {                /* d'abord la preface PostScript */
  884.    char * filenom = PSFILE;
  885.    FILE * file;
  886.    char t[1024];
  887.  
  888.    if ((file = fopen(filenom, "r")) == 0){
  889.      perror(filenom);
  890.      exit(0);
  891.    }
  892.    while((compte = fread(t, sizeof t[0], sizeof t, file)) > 0)
  893.      fwrite(t, sizeof t[0], compte, stdout);
  894.    if (compte != 0)
  895.      perror(filenom);
  896.  }
  897.                 /* parser les args ou stdin */
  898.   if (ac == 1){
  899.     if (yyparse() == 0){
  900.       arbre2ps(racine);
  901.       ancien(racine);
  902.     }
  903.   } else
  904.     for(compte = 0; --ac > 0; compte += 1)
  905.       if (strcmp((++ av)[0], "-") != 0 && freopen(av[0], "r", stdin) != NULL){
  906.     file = av[0];
  907.     lino = 1;
  908.     if (yyparse() == 0){
  909.       arbre2ps(racine);
  910.       ancien(racine);
  911.     }
  912.       } else
  913.     perror(av[0]);
  914.   psfinir(compte);
  915. }
  916.  
  917. yyerror(){
  918.   fprintf(stderr, "%s:%d: le parseur a un probleme avec %s\n",
  919.       file, lino, yytext);
  920. }
  921. noparse(){
  922.   fprintf(stderr, "%s:%d: je ne parse pas %s\n", file, lino, yytext);
  923. }
  924. merror(){
  925.   fprintf(stderr, "Plus de memoire\n");
  926. }
  927.  
  928. /* strcherche  --  brutal, mais c'est fait une seule fois par partie */
  929. static char * strcherche(modele, texte) char * modele, * texte; {
  930.   int i, lm, lt;
  931.  
  932.   lm = strlen(modele);
  933.   lt = strlen(texte);
  934.   if (lm > lt)
  935.     return 0;
  936.   else {
  937.     for(i = 0; texte[i + lm] != 0; i += 1)
  938.       if (strncmp(modele, &texte[i], lm) == 0)
  939.     return & texte[i];
  940.     return strcmp(modele, & texte[i]) == 0 ? & texte[i] : 0;
  941.   }
  942. }
  943.  
  944. int nnoeud, ncoup, nvariante, ncommentaire;
  945. /* compter  --  compter et nmeroter coups et variantes */
  946. void compter(n) Noeud * n; {
  947.   nnoeud += 1;
  948.   n->numcoup = (ncoup += (n->couleur == BLANC || n->couleur == NOIR));
  949.   nvariante += (n->flag == VARIANTE);
  950.   ncommentaire += (n->commentaire != 0);
  951. }
  952.  
  953. /* handicap_compter  --  ajouter les pierres de handicap et les compter */
  954. void handicap_compter(n) Noeud * n; {
  955.   char * p;
  956.  
  957.   if (n->commentaire && (p = strcherche("Handicap: ", n->commentaire)) != 0){
  958.     int npierres = atoi(p + strlen("Handicap: "));
  959.     static int huit[][2] = { { 16, 4}, { 4,  16}, {  16, 16}, { 4, 4},
  960.                  { 16, 10}, { 4, 10}, { 10, 16}, { 10, 4} };
  961.     static int cinq[][2] = { { 10, 10} };
  962.     int i;
  963.  
  964.     if (npierres > 9  || npierres < 0)
  965.       fprintf(stderr, "%d pierres de handicap : je ne sais pas les poser\n", npierres);
  966.     if (npierres > 4 && npierres % 2 == 1){
  967.       ajoute_pierre(n, cinq[0][0], cinq[0][1]);
  968.       npierres -= 1;
  969.     }
  970.     for(i =  1; i <= npierres && i <= sizeof huit / sizeof huit[0]; i += 1)
  971.       ajoute_pierre(n, huit[i - 1][0], huit[i - 1][1]);
  972.   }
  973. }
  974. ajoute_pierre(r, n, m) Noeud * r; int n, m; {
  975.   Noeud * x;
  976.  
  977.   ncoup += 1;
  978.   x = nouvo();
  979.   x->flag = HANDICAP;
  980.   x->numcoup = 0;
  981.   x->position = Pt(n, m);
  982.   x->couleur = NOIR;
  983.  
  984.   x->next = r->next;
  985.   r->next = x;
  986. }
  987.  
  988. Noeud * pose[1+GOBAN][1+GOBAN];
  989. int ndessus;
  990. int ndessous;
  991. int maxdessus;
  992.  
  993. /* couvrir  --  marque, pour chaque pierre, celle qui est dessous, combien elle en a dessus */
  994. void couvrir(n) Noeud * n; {
  995.   if (n->flag == HANDICAP){
  996.     assert(pose[n->position.x][n->position.y] == 0);
  997.     pose[n->position.x][n->position.y] = n;
  998.   } else
  999.     if (n->couleur == BLANC || n->couleur == NOIR)
  1000.       if (pose[n->position.x][n->position.y] == 0)
  1001.     pose[n->position.x][n->position.y] = n;
  1002.       else {
  1003.     ndessus += 1;
  1004.     n->dessous = pose[n->position.x][n->position.y];
  1005.     if ((n->dessous->ndessus += 1) > maxdessus)
  1006.       maxdessus = n->dessous->ndessus;
  1007.     if (n->dessous->ndessus == 1)
  1008.       ndessous += 1;
  1009.       }
  1010. }
  1011. /* handicap_couvrir  --  numerote *negativement* les pierres de handicap recouvertes */
  1012. handicap_couvrir(n) Noeud * n; {
  1013.   int compte = -1;
  1014.  
  1015.   for(n = n->next; n->flag == HANDICAP; n = n->next)
  1016.     if (n->ndessus != 0)
  1017.       n->numcoup = compte--;
  1018. }  
  1019.  
  1020.  
  1021. /* nomme  --  renvoie le nom d'un coup sous forme de char *, a utiliser vite */
  1022. char * nomme(n) Noeud * n; {
  1023. # define MAXNOMME 4        /* apres on ecrase */
  1024.   static char noms[MAXNOMME][4];
  1025.   static int inoms = 0;;
  1026.  
  1027.   assert(n->couleur == BLANC || n->couleur == NOIR);
  1028.  
  1029.   inoms %= MAXNOMME;
  1030.   if (n->numcoup > 0)
  1031.     sprintf(noms[inoms], "%d", n->numcoup);
  1032.   else if (n->numcoup < 0)
  1033.     sprintf(noms[inoms], "%c", 'a' - (n->numcoup + 1));
  1034.   else
  1035.     noms[inoms][0] = 0;
  1036.  
  1037.   return noms[inoms++];
  1038. }
  1039.  
  1040. /* applique  --  applique la fonction f au noeud, a son fils, au suivant */
  1041. void applique(n, f) Noeud * n; void (*f)(); {
  1042.   f(n);
  1043.   if (n->fils != 0)
  1044.     applique(n->fils, f);
  1045.   if (n->next != 0)
  1046.     applique(n->next, f);
  1047. }
  1048.  
  1049. static int npages;
  1050.  
  1051. /* arbre2ps  --  traduit l'arbre de coups en p*stscript */
  1052. void
  1053. arbre2ps(n)
  1054.      Noeud * n;
  1055. {
  1056.   int pscouvre(), pscoups(), pscommentaires(), koprep();
  1057.  
  1058.                 /* compte noeuds, coups et variantes */
  1059.   nnoeud = ncoup = nvariante = 0;
  1060.   applique(n, compter);
  1061.   handicap_compter(n);
  1062.   printf("%% %d noeuds, %d coups, %d variantes %d commentaires\n",
  1063.      nnoeud, ncoup, nvariante, ncommentaire);
  1064.   if (nvariante > 0)
  1065.     printf("%% Il y a %d variantes; je ne sais pas traiter les variantes\n",
  1066.        nvariante);
  1067.                 /* compte les recouvrements */
  1068.   { int i, j;
  1069.  
  1070.     for(i = 1; i <= GOBAN; i += 1)
  1071.       for(j = 1; j < GOBAN; j += 1)
  1072.     pose[i][j] = 0;
  1073.     ndessous = ndessus = maxdessus = 0;
  1074.     applique(n, couvrir);
  1075.     handicap_couvrir(n);
  1076. printf("%% %d pierres en pile (hauteur max : %d) sur %d endroits\n",
  1077.        ndessus, maxdessus, ndessous);
  1078.   }    
  1079.  
  1080.   printf("%%%%Page %d %d\n\nsave\ninitHaut\n", npages, npages + 1);
  1081.   npages += 1;
  1082.  
  1083.   /* titre */
  1084.   if (racine->commentaire != 0){
  1085.     printf("[ ");
  1086.     pschaine(racine->commentaire, "");
  1087.     printf(" ] titres\n\n");
  1088.   }
  1089.  
  1090.   /* le goban (ca place aussi les coordoonnees pour le reste) */
  1091.   printf("goban\n\n");
  1092.  
  1093.   /* pierres sur le goban */
  1094.   printf("[ ");
  1095.   applique(racine, pscoups);
  1096.   printf(" ] coups\n\n");
  1097.  
  1098.   /*
  1099.     se debrouiller avec les pierres recouvertes les unes par les autres :
  1100.     s'il y en a moins de 18, on peut les placer a droite du goban
  1101.     sinon, on traite les repetitions les plus frequentes comme des kos
  1102.    */
  1103.   if (ndessus != 0){
  1104.     extern int kolim;
  1105.  
  1106.     if (ndessus > 18){
  1107.  
  1108.       kolim = 3;
  1109.       applique(racine, koprep);
  1110.       printf("[ ");
  1111.       psko();
  1112.       printf(" ] kos\n");
  1113.       kofin();
  1114.     } else
  1115.       kolim = maxdessus;    /* pas de limite */
  1116.  
  1117.     printf("[ ");
  1118.     applique(racine, pscouvre);
  1119.     printf(" ] couvres\n\n");
  1120.   }
  1121.  
  1122.   /* commentaires */
  1123.   printf("[ ");
  1124.   applique(racine, pscommentaires);
  1125.   printf(" ] commentaires\n\n");
  1126.  
  1127.   printf("\n\nshowpage\n\nrestore\n\n");
  1128. }
  1129.  
  1130. /* psfinir  --  terminer le traitement d'un fichier */
  1131. psfinir(n) int n; {
  1132.   printf("%%%%Pages: %d\n", n);
  1133. }
  1134.  
  1135. /* pschaine  --  applique psfonc a toutes les lignes contenues dans s */
  1136. pschaine(s, psfonc) char * s, * psfonc; {
  1137.   char sauvecar = s[0];
  1138.  
  1139.   while(sauvecar != 0){
  1140.     char * p, * pp;
  1141.                 /* avance p jusqu'a la fin de la ligne */
  1142.     for(p = s; *p != 0 && *p != '\n'; p += 1)
  1143.       ;
  1144.     sauvecar = *p;
  1145.     *p = 0;
  1146. /* ad'hoc : n'affiche pas les lignes qui se terminent par ':' */
  1147.                 /* recule pp jusqu'au dernier car. */
  1148.     for(pp = p - 1; pp != s && *pp == ' '; pp -= 1)
  1149.       ;
  1150.     if (pp != s && *pp != ':')
  1151. /* fin du ad'hoc */
  1152.       printf("(%s) %s\n", s, psfonc);
  1153.     s = p + 1;
  1154.   }
  1155. }
  1156.  
  1157. /*
  1158.  Traitement des pierres recouvertes les unes par les autres
  1159.  */
  1160. int kolim;            /* hauteur de la pile avant de faire un ko */
  1161.  
  1162. /* pscouvre  --  le cas echeant, affiche le noeud comme "X en Y" */
  1163. pscouvre(n) Noeud * n; {
  1164.   if (n->dessous != 0 && n->dessous->ndessus <= kolim)
  1165.     printf("[ (%s) %d [ (%s) %d] ]\n",
  1166.        nomme(n->dessous), n->dessous->couleur, nomme(n), n->couleur);
  1167. }  
  1168.  
  1169. /* les piles de pierres pose'es quelquepart */
  1170. struct ko {
  1171.   Noeud * dessous;        /* qui est dessous */
  1172.   int ndessus;            /* combien il y en a dessus */
  1173.   Noeud ** dessus;        /* (les adresses de) ceux qui sont dessus */
  1174. } * kos;
  1175.  
  1176. /* koprep  --  le cas echeant, empile sur la pile des X en Y */
  1177. koprep(n) Noeud * n; {
  1178.   if (n->dessous != 0)
  1179.     if (n->dessous->ndessus > kolim){
  1180.       Noeud * sous = n->dessous;
  1181.       int i;
  1182.                 /* alloue si necessaire */
  1183.       if (kos == 0 && (kos = (struct ko *)calloc(ndessous, sizeof kos[0])) == 0)
  1184.     merror();
  1185.       for(i = 0; kos[i].dessous != 0; i += 1)
  1186.     if (kos[i].dessous == sous)
  1187.       break;
  1188.       if (kos[i].dessous == 0){
  1189.     kos[i].dessous = sous;
  1190.     if ((kos[i].dessus
  1191.          = (Noeud **)calloc(sous->ndessus, sizeof kos[0].dessus[0])) == 0)
  1192.       merror();
  1193.     kos[i].ndessus = 0;
  1194.       }
  1195.                 /* ajoute sur la pile */
  1196.       kos[i].dessus[kos[i].ndessus++] = n;
  1197.     }
  1198. }
  1199.  
  1200. /* psko  --  affiche les empilements */
  1201. psko(){
  1202.  int i, j;
  1203.  
  1204.  for(i = 0; i < ndessous && kos[i].dessous != 0; i += 1){
  1205.    printf("[ (%s) %d [", nomme(kos[i].dessous), kos[i].dessous->couleur);
  1206.    for(j = 0; j < kos[i].ndessus; j += 1)
  1207.      printf(" (%s) %d", nomme(kos[i].dessus[j]), kos[i].dessus[j]->couleur);
  1208.    printf("] ]\n");
  1209.  }
  1210. }
  1211.  
  1212. /* kofin  --  libere la memoire es empilements */
  1213. kofin(){
  1214.   if (kos != 0){
  1215.     int i;
  1216.  
  1217.     for(i = 0; i < ndessous; i += 1)
  1218.       free(kos[i].dessus);
  1219.     free(kos);
  1220.     kos = 0;
  1221.   }
  1222. }
  1223.  
  1224. /* pscoups  --  affiche un coup */
  1225. pscoups(n) Noeud * n; {
  1226.   if ((n->couleur == BLANC || n->couleur == NOIR) && n->dessous == 0)
  1227.     printf("[ (%s) %d %d %d ]\n", nomme(n), n->couleur, n->position.x,
  1228.        n->position.y);
  1229. }
  1230.  
  1231. /* pscommentaires  --  affiche un commentaire, avec son coup */
  1232. pscommentaires(n) Noeud * n; {
  1233.   if (n->commentaire != 0 && n != racine){
  1234.     printf("[ (%s) %d (%s) ]\n", nomme(n), n->couleur, n->commentaire);
  1235.   }
  1236. }
  1237. SHAR_EOF
  1238. fi
  1239. exit 0
  1240. #    End of shell archive
  1241.